{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 21点游戏的蒙特卡洛学习策略迭代"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from random import shuffle\n",
    "from queue import Queue\n",
    "from tqdm import tqdm\n",
    "import math\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "from mpl_toolkits.mplot3d import Axes3D\n",
    "from utils import str_key, set_dict, get_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Gamer():\n",
    "    '''游戏者\n",
    "    '''\n",
    "    def __init__(self, name = \"\", A = None, display = False):\n",
    "        self.name = name\n",
    "        self.cards = [] # 手中的牌\n",
    "        self.display = display # 是否显示对局文字信息\n",
    "        self.policy = None # 策略\n",
    "        self.learning_method = None # 学习方法\n",
    "        self.A = A # 行为空间\n",
    "        \n",
    "    def __str__(self):\n",
    "        return self.name\n",
    "    \n",
    "    def _value_of(self, card):\n",
    "        '''根据牌的字符判断牌的数值大小，A被输出为1, JQK均为10，其余按牌字符对应的数字取值\n",
    "        Args:\n",
    "            card: 牌面信息 str\n",
    "        Return:\n",
    "            牌的大小数值 int, A 返回 1\n",
    "        '''\n",
    "        try:\n",
    "            v = int(card)\n",
    "        except:\n",
    "            if card == 'A':\n",
    "                v = 1\n",
    "            elif card in ['J','Q','K']:\n",
    "                v = 10\n",
    "            else:\n",
    "                v = 0\n",
    "        finally:\n",
    "            return v\n",
    "    \n",
    "    def get_points(self):\n",
    "        '''统计一手牌分值，如果使用了A的1点，同时返回True\n",
    "        Args:\n",
    "            cards 庄家或玩家手中的牌 list ['A','10','3']\n",
    "        Return\n",
    "            tuple (返回牌总点数,是否使用了可复用Ace) \n",
    "            例如['A','10','3'] 返回 (14, False)\n",
    "               ['A','10'] 返回 （21, True)\n",
    "        '''\n",
    "        num_of_useable_ace = 0 # 默认没有拿到Ace\n",
    "        total_point = 0 # 总值\n",
    "        cards = self.cards\n",
    "        if cards is None:\n",
    "            return 0, False\n",
    "        for card in cards:\n",
    "            v = self._value_of(card)\n",
    "            if v == 1:\n",
    "                num_of_useable_ace += 1\n",
    "                v = 11\n",
    "            total_point += v\n",
    "        while total_point > 21 and num_of_useable_ace > 0:\n",
    "            total_point -= 10\n",
    "            num_of_useable_ace -= 1\n",
    "        return total_point, bool(num_of_useable_ace)\n",
    "    \n",
    "    def receive(self, cards = []): # 玩家获得一张或多张牌\n",
    "        cards = list(cards)\n",
    "        for card in cards:\n",
    "            self.cards.append(card)\n",
    "    \n",
    "    def discharge_cards(self): # 玩家把手中的牌清空，扔牌\n",
    "        '''扔牌\n",
    "        '''\n",
    "        self.cards.clear()\n",
    "    \n",
    "    \n",
    "    def cards_info(self): # 玩家手中牌的信息\n",
    "        '''\n",
    "        显示牌面具体信息\n",
    "        '''\n",
    "        self._info(\"{}{}现在的牌:{}\\n\".format(self.role, self,self.cards))\n",
    "    \n",
    "    def _info(self, msg):\n",
    "        if self.display:\n",
    "            print(msg, end=\"\")\n",
    "        \n",
    "        \n",
    "class Dealer(Gamer):\n",
    "    def __init__(self, name = \"\", A = None, display = False):\n",
    "        super(Dealer,self).__init__(name, A, display)\n",
    "        self.role = \"庄家\"\n",
    "        self.policy = self.dealer_policy\n",
    "    \n",
    "    def first_card_value(self):\n",
    "        if self.cards is None or len(self.cards) == 0:\n",
    "            return 0\n",
    "        return self._value_of(self.cards[0])\n",
    "    \n",
    "    def dealer_policy(self, Dealer = None):\n",
    "        action = \"\"\n",
    "        dealer_points, _ = self.get_points()\n",
    "        if dealer_points >= 17:\n",
    "            action = self.A[1] # \"停止要牌\"\n",
    "        else:\n",
    "            action = self.A[0]\n",
    "        return action\n",
    "        \n",
    "\n",
    "class Player(Gamer):\n",
    "    def __init__(self, name = \"\", A = None, display = False):\n",
    "        super(Player, self).__init__(name, A, display)\n",
    "        self.policy = self.naive_policy\n",
    "        self.role = \"玩家\" # “庄家”还是“玩家”，庄家是特殊的玩家\n",
    "    \n",
    "    def get_state(self, dealer):\n",
    "        dealer_first_card_value = dealer.first_card_value()\n",
    "        player_points, useable_ace = self.get_points()\n",
    "        return dealer_first_card_value, player_points, useable_ace\n",
    "        \n",
    "    def get_state_name(self, dealer):\n",
    "        return str_key(self.get_state(dealer))\n",
    "\n",
    "    def naive_policy(self, dealer=None):\n",
    "        player_points, _ = self.get_points()\n",
    "        if player_points < 20:\n",
    "            action = self.A[0]\n",
    "        else:\n",
    "            action = self.A[1]        \n",
    "        return action  \n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Arena():\n",
    "    '''负责游戏管理\n",
    "    '''\n",
    "    def __init__(self, display = None, A = None):\n",
    "        self.cards = ['A','2','3','4','5','6','7','8','9','10','J','Q',\"K\"]*4\n",
    "        self.card_q = Queue(maxsize = 52) # 洗好的牌\n",
    "        self.cards_in_pool = [] # 已经用过的公开的牌  \n",
    "        self.display = display\n",
    "        self.episodes = [] # 产生的对局信息列表\n",
    "        self.load_cards(self.cards)# 把初始状态的52张牌装入发牌器\n",
    "        self.A = A # 获得行为空间\n",
    "\n",
    "    def load_cards(self, cards):\n",
    "        '''把收集的牌洗一洗，重新装到发牌器中\n",
    "        Args:\n",
    "            cards 要装入发牌器的多张牌 list\n",
    "        Return:\n",
    "            None\n",
    "        '''\n",
    "        shuffle(cards) # 洗牌\n",
    "        for card in cards:# deque数据结构只能一个一个添加\n",
    "            self.card_q.put(card)\n",
    "        cards.clear() # 原来的牌清空\n",
    "        return\n",
    "       \n",
    "    def reward_of(self, dealer, player):\n",
    "        '''判断玩家奖励值，附带玩家、庄家的牌点信息\n",
    "        '''\n",
    "        dealer_points, _ = dealer.get_points()\n",
    "        player_points, useable_ace = player.get_points()\n",
    "        if player_points > 21:\n",
    "            reward = -1\n",
    "        else:\n",
    "            if player_points > dealer_points or dealer_points > 21:\n",
    "                reward = 1\n",
    "            elif player_points == dealer_points:\n",
    "                reward = 0\n",
    "            else:\n",
    "                reward = -1\n",
    "        return reward, player_points, dealer_points, useable_ace\n",
    "    \n",
    "    def serve_card_to(self, player, n = 1):\n",
    "        '''给庄家或玩家发牌，如果牌不够则将公开牌池的牌洗一洗重新发牌\n",
    "        Args:\n",
    "            player 一个庄家或玩家 \n",
    "            n 一次连续发牌的数量\n",
    "        Return:\n",
    "            None\n",
    "        '''\n",
    "        cards = []  #将要发出的牌\n",
    "        for _ in range(n):\n",
    "            # 要考虑发牌器没有牌的情况\n",
    "            if self.card_q.empty():\n",
    "                self._info(\"\\n发牌器没牌了，整理废牌，重新洗牌;\")\n",
    "                shuffle(self.cards_in_pool)\n",
    "                self._info(\"一共整理了{}张已用牌，重新放入发牌器\\n\".format(len(self.cards_in_pool)))\n",
    "                assert(len(self.cards_in_pool) > 20) # 确保有足够的牌，将该数值设置成40左右时，如果玩家\n",
    "                # 即使爆点了也持续的叫牌，会导致玩家手中牌变多而发牌器和已使用的牌都很少，需避免这种情况。\n",
    "                self.load_cards(self.cards_in_pool) # 将收集来的用过的牌洗好送入发牌器重新使用\n",
    "            cards.append(self.card_q.get()) # 从发牌器发出一章牌\n",
    "        self._info(\"发了{}张牌({})给{}{};\".format(n, cards, player.role, player))\n",
    "        #self._info(msg)\n",
    "        player.receive(cards) # 牌已发给某一玩家\n",
    "        player.cards_info()\n",
    "\n",
    "        \n",
    "    def _info(self, message):\n",
    "        if self.display:\n",
    "            print(message, end=\"\")\n",
    "        \n",
    "    def recycle_cards(self, *players):\n",
    "        '''回收玩家手中的牌到公开使用过的牌池中\n",
    "        '''\n",
    "        if len(players) == 0:\n",
    "            return\n",
    "        for player in players:\n",
    "            for card in player.cards:\n",
    "                self.cards_in_pool.append(card)\n",
    "            player.discharge_cards() # 玩家手中不再留有这些牌\n",
    "                \n",
    "    def play_game(self, dealer, player):\n",
    "        '''玩一局21点，生成一个状态序列以及最终奖励（中间奖励为0）\n",
    "        Args：\n",
    "            dealer/player 庄家和玩家手中的牌 list\n",
    "        Returns:\n",
    "            tuple：episode, reward\n",
    "        '''\n",
    "        #self.collect_player_cards()\n",
    "        self._info(\"========= 开始新一局 =========\\n\")\n",
    "        self.serve_card_to(player, n=2) # 发两张牌给玩家\n",
    "        self.serve_card_to(dealer, n=2) # 发两张牌给庄家\n",
    "        episode = [] # 记录一个对局信息\n",
    "        if player.policy is None:\n",
    "            self._info(\"玩家需要一个策略\")\n",
    "            return\n",
    "        if dealer.policy is None:\n",
    "            self._info(\"庄家需要一个策略\")\n",
    "            return\n",
    "        while True:\n",
    "            action = player.policy(dealer)\n",
    "            # 玩家的策略产生一个行为\n",
    "            self._info(\"{}{}选择:{};\".format(player.role, player, action))\n",
    "            episode.append((player.get_state_name(dealer), action)) # 记录一个(s,a)\n",
    "            if action == self.A[0]: # 继续叫牌\n",
    "                self.serve_card_to(player) # 发一张牌给玩家\n",
    "            else: # 停止叫牌\n",
    "                break\n",
    "        # 玩家停止叫牌后要计算下玩家手中的点数，玩家如果爆了，庄家就不用继续了        \n",
    "        reward, player_points, dealer_points, useable_ace = self.reward_of(dealer, player)\n",
    "        \n",
    "        if player_points > 21:\n",
    "            self._info(\"玩家爆点{}输了，得分:{}\\n\".format(player_points, reward))\n",
    "            self.recycle_cards(player, dealer)\n",
    "            self.episodes.append((episode, reward)) # 预测的时候需要形成episode list后同一学习V\n",
    "            # 在蒙特卡洛控制的时候，可以不需要episodes list,生成一个episode学习一个，下同\n",
    "            self._info(\"========= 本局结束 ==========\\n\")\n",
    "            return episode, reward\n",
    "        # 玩家并没有超过21点\n",
    "        self._info(\"\\n\")\n",
    "        while True:\n",
    "            action = dealer.policy() # 庄家从其策略中获取一个行为\n",
    "            self._info(\"{}{}选择:{};\".format(dealer.role, dealer, action))\n",
    "            if action == self.A[0]: # 庄家\"继续要牌\":\n",
    "                self.serve_card_to(dealer)\n",
    "                # 停止要牌是针对玩家来说的，episode不记录庄家动作\n",
    "                # 在状态只记录庄家第一章牌信息时，可不重复记录(s,a)，因为此时玩家不再叫牌，(s,a)均相同\n",
    "                # episode.append((get_state_name(dealer, player), self.A[1]))\n",
    "            else:\n",
    "                break\n",
    "        # 双方均停止叫牌了    \n",
    "        self._info(\"\\n双方均了停止叫牌;\\n\")\n",
    "        reward, player_points, dealer_points, useable_ace = self.reward_of(dealer, player)\n",
    "        player.cards_info() \n",
    "        dealer.cards_info()\n",
    "        if reward == +1:\n",
    "            self._info(\"玩家赢了!\")\n",
    "        elif reward == -1:\n",
    "            self._info(\"玩家输了!\")\n",
    "        else:\n",
    "            self._info(\"双方和局!\")\n",
    "        self._info(\"玩家{}点,庄家{}点\\n\".format(player_points, dealer_points))\n",
    "        \n",
    "        self._info(\"========= 本局结束 ==========\\n\")\n",
    "        self.recycle_cards(player, dealer) # 回收玩家和庄家手中的牌至公开牌池\n",
    "        self.episodes.append((episode, reward)) # 将刚才产生的完整对局添加值状态序列列表，蒙特卡洛控制不需要\n",
    "        return episode, reward\n",
    "    \n",
    "    def play_games(self, dealer, player, num=2, show_statistic = True):\n",
    "        '''一次性玩多局游戏\n",
    "        '''\n",
    "        results = [0, 0, 0]# 玩家负、和、胜局数\n",
    "        self.episodes.clear()\n",
    "        for i in tqdm(range(num)):\n",
    "            episode, reward = self.play_game(dealer, player)\n",
    "            results[1+reward] += 1\n",
    "            if player.learning_method is not None:\n",
    "                player.learning_method(episode ,reward)\n",
    "        if show_statistic:\n",
    "            print(\"共玩了{}局，玩家赢{}局，和{}局，输{}局，胜率：{:.2f},不输率:{:.2f}\"\\\n",
    "              .format(num, results[2],results[1],results[0],results[2]/num,(results[2]+results[1])/num))\n",
    "        pass\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "A=[\"继续叫牌\",\"停止叫牌\"]\n",
    "display = False\n",
    "# 创建一个玩家一个庄家，玩家使用原始策略，庄家使用其固定的策略\n",
    "player = Player(A = A, display = display)\n",
    "dealer = Dealer(A = A, display = display)\n",
    "# 创建一个场景\n",
    "arena = Arena(A = A, display=display)\n",
    "# 生成num个完整的对局"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 200000/200000 [00:19<00:00, 10507.56it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "共玩了200000局，玩家赢58296局，和11318局，输130386局，胜率：0.29,不输率:0.35\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "arena.play_games(dealer, player, num=200000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 统计个状态的价值，衰减因子为1，中间状态的即时奖励为0，递增式蒙特卡洛评估\n",
    "def policy_evaluate(episodes, V, Ns):\n",
    "    for episode, r in episodes:\n",
    "        for s, a in episode:\n",
    "            ns = get_dict(Ns, s)\n",
    "            v = get_dict(V, s)\n",
    "            set_dict(Ns, ns+1, s)\n",
    "            set_dict(V, v+(r-v)/(ns+1), s)\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "V = {} # 状态价值字典\n",
    "Ns = {} # 状态被访问的次数节点\n",
    "policy_evaluate(arena.episodes, V, Ns) # 学习V值\n",
    "#print(V)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def draw_value(value_dict, useable_ace = True, is_q_dict = False, A = None):\n",
    "    # 定义figure\n",
    "    fig = plt.figure()\n",
    "    # 将figure变为3d\n",
    "    ax = Axes3D(fig)\n",
    "    # 定义x, y\n",
    "    x = np.arange(1, 11, 1) # 庄家第一张牌\n",
    "    y = np.arange(12, 22, 1) # 玩家总分数\n",
    "    # 生成网格数据\n",
    "    X, Y = np.meshgrid(x, y)\n",
    "    # 从V字典检索Z轴的高度\n",
    "    row, col = X.shape\n",
    "    Z = np.zeros((row,col))\n",
    "    if is_q_dict:\n",
    "        n = len(A)\n",
    "    for i in range(row):\n",
    "        for j in range(col):\n",
    "            state_name = str(X[i,j])+\"_\"+str(Y[i,j])+\"_\"+str(useable_ace)\n",
    "            if not is_q_dict:\n",
    "                Z[i,j] = get_dict(value_dict, state_name)\n",
    "            else:\n",
    "                assert(A is not None)\n",
    "                for a in A:\n",
    "                    new_state_name = state_name + \"_\" + str(a)\n",
    "                    q = get_dict(value_dict, new_state_name)\n",
    "                    if q >= Z[i,j]:\n",
    "                        Z[i,j] = q\n",
    "    # 绘制3D曲面\n",
    "    ax.plot_surface(X, Y, Z, rstride = 1, cstride = 1, color=\"lightgray\")\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "draw_value(V, useable_ace = True, A = A) # 绘制状态价值图\n",
    "draw_value(V, useable_ace = False, A = A) # 绘制状态价值图"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 2/2 [00:00<00:00, 2170.40it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "========= 开始新一局 =========\n",
      "发了2张牌(['4', '4'])给玩家;玩家现在的牌:['4', '4']\n",
      "发了2张牌(['6', 'J'])给庄家;庄家现在的牌:['6', 'J']\n",
      "玩家选择:继续叫牌;发了1张牌(['2'])给玩家;玩家现在的牌:['4', '4', '2']\n",
      "玩家选择:继续叫牌;发了1张牌(['6'])给玩家;玩家现在的牌:['4', '4', '2', '6']\n",
      "玩家选择:继续叫牌;发了1张牌(['6'])给玩家;玩家现在的牌:['4', '4', '2', '6', '6']\n",
      "玩家选择:停止叫牌;玩家爆点22输了，得分:-1\n",
      "========= 本局结束 ==========\n",
      "========= 开始新一局 =========\n",
      "发了2张牌(['A', '2'])给玩家;玩家现在的牌:['A', '2']\n",
      "发了2张牌(['8', '7'])给庄家;庄家现在的牌:['8', '7']\n",
      "玩家选择:继续叫牌;发了1张牌(['A'])给玩家;玩家现在的牌:['A', '2', 'A']\n",
      "玩家选择:继续叫牌;发了1张牌(['7'])给玩家;玩家现在的牌:['A', '2', 'A', '7']\n",
      "玩家选择:停止叫牌;\n",
      "庄家选择:继续叫牌;发了1张牌(['10'])给庄家;庄家现在的牌:['8', '7', '10']\n",
      "庄家选择:停止叫牌;\n",
      "双方均了停止叫牌;\n",
      "玩家现在的牌:['A', '2', 'A', '7']\n",
      "庄家现在的牌:['8', '7', '10']\n",
      "玩家赢了!玩家21点,庄家25点\n",
      "========= 本局结束 ==========\n",
      "共玩了2局，玩家赢1局，和0局，输1局，胜率：0.50,不输率:0.50\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "# 观察几局对局信息\n",
    "display = True\n",
    "player.display, dealer.display, arena.display = display, display, display\n",
    "arena.play_games(dealer, player, num =2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. 蒙特卡洛控制"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "from utils import epsilon_greedy_policy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MC_Player(Player):\n",
    "    def __init__(self, name = \"\", A = None, display = False):\n",
    "        super(MC_Player, self).__init__(name, A, display)\n",
    "        self.Q = {}   # 某一状态行为对的价值，策略迭代时使用\n",
    "        self.Nsa = {} # Nsa的计数：某一状态行为对出现的次数\n",
    "        self.total_learning_times = 0\n",
    "        self.policy = self.greedy_policy\n",
    "        self.learning_method = self.learn_Q\n",
    "    \n",
    "    def learn_Q(self, episode, r): # 从状态序列来学习Q值\n",
    "        '''从Episode学习\n",
    "        '''\n",
    "        #for episode, r in episodes:\n",
    "        for s, a in episode:\n",
    "            nsa = get_dict(self.Nsa, s, a)\n",
    "            set_dict(self.Nsa, nsa+1, s, a)\n",
    "            q = get_dict(self.Q, s,a)\n",
    "            set_dict(self.Q, q+(r-q)/(nsa+1), s, a)\n",
    "        self.total_learning_times += 1\n",
    "    \n",
    "    def reset_memory(self):\n",
    "        '''忘记既往学习经历\n",
    "        '''\n",
    "        self.Q.clear()\n",
    "        self.Nsa.clear()\n",
    "        self.total_learning_times = 0\n",
    "\n",
    "    \n",
    "    def greedy_policy(self, dealer, epsilon = None):\n",
    "        player_points, _ = self.get_points()\n",
    "        if player_points >= 21:\n",
    "            return self.A[1]\n",
    "        if player_points < 12:\n",
    "            return self.A[0]\n",
    "        else:\n",
    "            A, Q = self.A, self.Q\n",
    "            s = self.get_state_name(dealer)\n",
    "            if epsilon is None:\n",
    "                #epsilon = 1.0/(self.total_learning_times+1)\n",
    "                #epsilon = 1.0/(1 + math.sqrt(1 + player.total_learning_times))\n",
    "                epsilon = 1.0/(1 + 4 * math.log10(1+player.total_learning_times))\n",
    "            return epsilon_greedy_policy(A, s, Q, epsilon)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "display = False\n",
    "player = MC_Player(A = A, display = display)\n",
    "dealer = Dealer(A = A, display = display)\n",
    "# 创建一个场景\n",
    "arena = Arena(A = A, display=display)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 2000000/2000000 [04:11<00:00, 7951.43it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "共玩了2000000局，玩家赢853503局，和179007局，输967490局，胜率：0.43,不输率:0.52\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "arena.play_games(dealer = dealer, player = player,num = 2000000, show_statistic = True)\n",
    "#print(player.Q)\n",
    "#print(player.A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "def draw_policy(policy, A, Q, epsilon, useable_ace = False):\n",
    "    def value_of(a):\n",
    "        if a == A[0]:\n",
    "            return 0\n",
    "        else:\n",
    "            return 1\n",
    "    rows, cols = 11, 10\n",
    "    useable_ace = bool(useable_ace)\n",
    "    Z = np.zeros((rows, cols))\n",
    "    dealer_first_card = np.arange(1, 12) # 庄家第一张牌\n",
    "    player_points = np.arange(12,22)\n",
    "    for i in range(11, 22): # 玩家总牌点\n",
    "        for j in range(1, 11): # 庄家第一张牌 \n",
    "            s = j, i, useable_ace\n",
    "            s = str_key(s)\n",
    "            a = policy(A, s, Q, epsilon)\n",
    "            Z[i-11,j-1] = value_of(a)\n",
    "            #print(s, a)\n",
    "    \n",
    "    plt.imshow(Z, cmap=plt.cm.cool, interpolation=None, origin=\"lower\", extent=[0.5,11.5,10.5,21.5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "draw_value(player.Q, useable_ace = True, is_q_dict=True, A = player.A)\n",
    "draw_policy(epsilon_greedy_policy, player.A, player.Q, epsilon = 1e-10, useable_ace = True)\n",
    "draw_value(player.Q, useable_ace = False, is_q_dict=True, A = player.A)\n",
    "draw_policy(epsilon_greedy_policy, player.A, player.Q, epsilon = 1e-10, useable_ace = False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 10000/10000 [00:01<00:00, 7908.94it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "共玩了10000局，玩家赢4411局，和915局，输4674局，胜率：0.44,不输率:0.53\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "display = False\n",
    "arena.display = display\n",
    "player.display = display\n",
    "dealer.display = display\n",
    "arena.play_games(dealer,player,num=10000, show_statistic = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 10/10 [00:00<00:00, 1836.39it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "========= 开始新一局 =========\n",
      "发了2张牌(['A', '7'])给玩家;玩家现在的牌:['A', '7']\n",
      "发了2张牌(['5', '3'])给庄家;庄家现在的牌:['5', '3']\n",
      "玩家选择:继续叫牌;发了1张牌(['2'])给玩家;玩家现在的牌:['A', '7', '2']\n",
      "玩家选择:停止叫牌;\n",
      "庄家选择:继续叫牌;发了1张牌(['9'])给庄家;庄家现在的牌:['5', '3', '9']\n",
      "庄家选择:停止叫牌;\n",
      "双方均了停止叫牌;\n",
      "玩家现在的牌:['A', '7', '2']\n",
      "庄家现在的牌:['5', '3', '9']\n",
      "玩家赢了!玩家20点,庄家17点\n",
      "========= 本局结束 ==========\n",
      "========= 开始新一局 =========\n",
      "发了2张牌(['4', '8'])给玩家;玩家现在的牌:['4', '8']\n",
      "发了2张牌(['7', 'Q'])给庄家;庄家现在的牌:['7', 'Q']\n",
      "玩家选择:继续叫牌;发了1张牌(['4'])给玩家;玩家现在的牌:['4', '8', '4']\n",
      "玩家选择:继续叫牌;发了1张牌(['10'])给玩家;玩家现在的牌:['4', '8', '4', '10']\n",
      "玩家选择:停止叫牌;玩家爆点26输了，得分:-1\n",
      "========= 本局结束 ==========\n",
      "========= 开始新一局 =========\n",
      "发了2张牌(['9', 'A'])给玩家;玩家现在的牌:['9', 'A']\n",
      "发了2张牌(['5', '7'])给庄家;庄家现在的牌:['5', '7']\n",
      "玩家选择:停止叫牌;\n",
      "庄家选择:继续叫牌;发了1张牌(['K'])给庄家;庄家现在的牌:['5', '7', 'K']\n",
      "庄家选择:停止叫牌;\n",
      "双方均了停止叫牌;\n",
      "玩家现在的牌:['9', 'A']\n",
      "庄家现在的牌:['5', '7', 'K']\n",
      "玩家赢了!玩家20点,庄家22点\n",
      "========= 本局结束 ==========\n",
      "========= 开始新一局 =========\n",
      "发了2张牌(['A', 'J'])给玩家;玩家现在的牌:['A', 'J']\n",
      "发了2张牌(['Q', 'Q'])给庄家;庄家现在的牌:['Q', 'Q']\n",
      "玩家选择:停止叫牌;\n",
      "庄家选择:停止叫牌;\n",
      "双方均了停止叫牌;\n",
      "玩家现在的牌:['A', 'J']\n",
      "庄家现在的牌:['Q', 'Q']\n",
      "玩家赢了!玩家21点,庄家20点\n",
      "========= 本局结束 ==========\n",
      "========= 开始新一局 =========\n",
      "发了2张牌(['9', '3'])给玩家;玩家现在的牌:['9', '3']\n",
      "发了2张牌(['2', '5'])给庄家;庄家现在的牌:['2', '5']\n",
      "玩家选择:继续叫牌;发了1张牌(['2'])给玩家;玩家现在的牌:['9', '3', '2']\n",
      "玩家选择:停止叫牌;\n",
      "庄家选择:继续叫牌;发了1张牌(['8'])给庄家;庄家现在的牌:['2', '5', '8']\n",
      "庄家选择:继续叫牌;发了1张牌(['A'])给庄家;庄家现在的牌:['2', '5', '8', 'A']\n",
      "庄家选择:继续叫牌;发了1张牌(['J'])给庄家;庄家现在的牌:['2', '5', '8', 'A', 'J']\n",
      "庄家选择:停止叫牌;\n",
      "双方均了停止叫牌;\n",
      "玩家现在的牌:['9', '3', '2']\n",
      "庄家现在的牌:['2', '5', '8', 'A', 'J']\n",
      "玩家赢了!玩家14点,庄家26点\n",
      "========= 本局结束 ==========\n",
      "========= 开始新一局 =========\n",
      "发了2张牌(['10', '10'])给玩家;玩家现在的牌:['10', '10']\n",
      "发了2张牌(['J', '7'])给庄家;庄家现在的牌:['J', '7']\n",
      "玩家选择:停止叫牌;\n",
      "庄家选择:停止叫牌;\n",
      "双方均了停止叫牌;\n",
      "玩家现在的牌:['10', '10']\n",
      "庄家现在的牌:['J', '7']\n",
      "玩家赢了!玩家20点,庄家17点\n",
      "========= 本局结束 ==========\n",
      "========= 开始新一局 =========\n",
      "发了2张牌(['10', '4'])给玩家;玩家现在的牌:['10', '4']\n",
      "\n",
      "发牌器没牌了，整理废牌，重新洗牌;一共整理了49张已用牌，重新放入发牌器\n",
      "发了2张牌(['6', '6'])给庄家;庄家现在的牌:['6', '6']\n",
      "玩家选择:停止叫牌;\n",
      "庄家选择:继续叫牌;发了1张牌(['9'])给庄家;庄家现在的牌:['6', '6', '9']\n",
      "庄家选择:停止叫牌;\n",
      "双方均了停止叫牌;\n",
      "玩家现在的牌:['10', '4']\n",
      "庄家现在的牌:['6', '6', '9']\n",
      "玩家输了!玩家14点,庄家21点\n",
      "========= 本局结束 ==========\n",
      "========= 开始新一局 =========\n",
      "发了2张牌(['6', 'A'])给玩家;玩家现在的牌:['6', 'A']\n",
      "发了2张牌(['K', '5'])给庄家;庄家现在的牌:['K', '5']\n",
      "玩家选择:继续叫牌;发了1张牌(['9'])给玩家;玩家现在的牌:['6', 'A', '9']\n",
      "玩家选择:继续叫牌;发了1张牌(['10'])给玩家;玩家现在的牌:['6', 'A', '9', '10']\n",
      "玩家选择:停止叫牌;玩家爆点26输了，得分:-1\n",
      "========= 本局结束 ==========\n",
      "========= 开始新一局 =========\n",
      "发了2张牌(['J', '3'])给玩家;玩家现在的牌:['J', '3']\n",
      "发了2张牌(['4', '7'])给庄家;庄家现在的牌:['4', '7']\n",
      "玩家选择:停止叫牌;\n",
      "庄家选择:继续叫牌;发了1张牌(['7'])给庄家;庄家现在的牌:['4', '7', '7']\n",
      "庄家选择:停止叫牌;\n",
      "双方均了停止叫牌;\n",
      "玩家现在的牌:['J', '3']\n",
      "庄家现在的牌:['4', '7', '7']\n",
      "玩家输了!玩家13点,庄家18点\n",
      "========= 本局结束 ==========\n",
      "========= 开始新一局 =========\n",
      "发了2张牌(['Q', '2'])给玩家;玩家现在的牌:['Q', '2']\n",
      "发了2张牌(['7', 'K'])给庄家;庄家现在的牌:['7', 'K']\n",
      "玩家选择:继续叫牌;发了1张牌(['J'])给玩家;玩家现在的牌:['Q', '2', 'J']\n",
      "玩家选择:停止叫牌;玩家爆点22输了，得分:-1\n",
      "========= 本局结束 ==========\n",
      "共玩了10局，玩家赢5局，和0局，输5局，胜率：0.50,不输率:0.50\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "display = True\n",
    "arena.display = display\n",
    "player.display = display\n",
    "dealer.display = display\n",
    "arena.play_games(dealer,player,num=10, show_statistic = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
